import re

from mysql_tool import extract_all_contents


class Check():
    def __init__(self, sql=None, rule_name=None):
        self.sql = sql
        self.rule_name = rule_name

    def process_key_v_3(self) -> bool:
        ###
        pattern = r"\s*row_number\(\s*\)\s*over\s*\(\s*partition\s+by\s+(\w+)\s*\)"
        match = re.compile(pattern, re.IGNORECASE).search(self.sql)
        # 如果匹配成功，并且匹配结果中包含ORDER BY，则返回True，否则返回False
        if match and "ORDER BY" in match.group().upper():
            return True
        elif match:
            print("row_number 校验异常 坐标{}".format(match))
            return False
        return True

    def process_key_v_7(self) -> bool:
        ### group_concat
        regex_pattern = r'GROUP_CONCAT\('
        contents = extract_all_contents(self.sql, regex_pattern)
        if contents:
            for sql_part in contents:
                print(sql_part)
                if "SEPARATOR" not in sql_part.upper():
                    print("group_concat 校验异常 {}".format(sql_part))
                    return False
                    # 构造正则表达式来检查ORDER BY之后的部分
                    # 注意：这个正则不能完美处理所有括号嵌套，仅用于简化情况
                order_by_pattern = r"(ORDER\s+BY\s+[^,]+(ASC|DESC)\b)"
                # 检查ORDER BY的存在与格式
                if "ORDER BY" in sql_part.upper():
                    # 使用正则查找ORDER BY后面是否符合规则
                    if not re.compile(order_by_pattern, re.IGNORECASE).search(sql_part):
                        # 如果ORDER BY后面有逗号或没有ASC/DESC，则返回False
                        if re.compile(r"ORDER\s+BY\s+[^,]+,\s*", re.IGNORECASE).search(sql_part) or \
                                not re.compile(r"ORDER\s+BY\s+.+\b(ASC|DESC)\b", re.IGNORECASE).search(sql_part):
                            print("group_concat 校验异常 {}".format(sql_part))
                            return False
                else:
                    # 如果没有ORDER BY，直接检查SEPARATOR即可，这里已在外层检查过
                    pass
        return True

    def process_key_v_9(self) -> bool:
        pattern = r"^(date_sub|date_add)\([^,]+,\s*interval\s+\(\d+\)\s+day\)$"
        if "DATE_SUB" not in self.sql.upper() and "DATE_ADD" not in self.sql.upper():
            return True
        # 使用正则表达式进行匹配
        matches = re.compile(pattern, re.IGNORECASE).match(self.sql)
        if not matches:
            return False
        return True

    def messages(self) -> bool:
        """
        根据字典的键迭代调用方法，将所有方法返回的消息拼接成一个字符串。
        :param keys_to_process: 包含键的列表，用于决定调用哪些方法。
        :return: 所有方法返回消息的拼接字符串。
        """
        method_name = f"process_key_{self.rule_name}"
        flag = True
        # 检查方法是否存在
        if hasattr(self, method_name) and callable(getattr(self, method_name)):
            flag = getattr(self, method_name)()
        return flag
